#include "pch.hpp"
#include "Container.hpp"




///////////////////////////////////////////////////////
// Implementation of a map container for allocations //
///////////////////////////////////////////////////////

struct alloc_map::impl : public container
{};
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_map::alloc_map()
	: d(new impl)
{}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_map::~alloc_map()
{}
///////////////////////////////////////////////////////////////////////////////////////////////////




void alloc_map::insert(const alloc_unit& unit)
{
	d->insert(std::make_pair(unit.address, unit));
}
///////////////////////////////////////////////////////////////////////////////////////////////////

void alloc_map::remove(const_iterator _Where)
{
	d->erase(_Where);
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_map::iterator alloc_map::find(void* address)
{
	return d->find(address);
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_unit& alloc_map::deref(iterator _Where) const
{
	return (*_Where).second;
}
///////////////////////////////////////////////////////////////////////////////////////////////////

const alloc_unit& alloc_map::deref(const_iterator _Where) const
{
	return (*_Where).second;
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_map::iterator alloc_map::begin()
{
	return d->begin();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_map::iterator alloc_map::end()
{
	return d->end();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_map::const_iterator alloc_map::begin() const
{
	return d->begin();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_map::const_iterator alloc_map::end() const
{
	return d->end();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

std::size_t alloc_map::size() const
{
	return d->size();
}
///////////////////////////////////////////////////////////////////////////////////////////////////




struct alloc_vector::impl : public container
{};
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_vector::alloc_vector( const alloc_map &that )
	: d(new impl)
{
	foreach(const alloc_map::value_type& pair, that)
	{
		d->push_back(pair.second);
	}

	std::sort(d->begin(), d->end(), &alloc_vector::sort_ascending);
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_vector::~alloc_vector()
{}
///////////////////////////////////////////////////////////////////////////////////////////////////




alloc_vector::iterator alloc_vector::begin()
{
	return d->begin();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_vector::iterator alloc_vector::end()
{
	return d->end();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_vector::const_iterator alloc_vector::begin() const
{
	return d->begin();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_vector::const_iterator alloc_vector::end() const
{
	return d->end();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

alloc_unit& alloc_vector::deref(iterator _Where) const
{
	return (*_Where);
}
///////////////////////////////////////////////////////////////////////////////////////////////////

const alloc_unit& alloc_vector::deref(const_iterator _Where) const
{
	return (*_Where);
}
///////////////////////////////////////////////////////////////////////////////////////////////////

std::size_t alloc_vector::size() const
{
	return d->size();
}
///////////////////////////////////////////////////////////////////////////////////////////////////

bool alloc_vector::sort_ascending(const alloc_unit& left, const alloc_unit& right)
{
	return left.id < right.id;
}
///////////////////////////////////////////////////////////////////////////////////////////////////
